Entrega Final
1 Introducción
A medida que el volumen y la complejidad de los datos han crecido exponencialmente en la era digital, la reducción de dimensionalidad se ha convertido en una técnica indispensable. Su objetivo es transformar datos de alta dimensión en una representación de menor dimensión, preservando al máximo la información relevante y la estructura inherente de los datos. Esta tarea es crucial no solo para la visualización y la comprensión de patrones, sino también para mejorar la eficiencia computacional de algoritmos de aprendizaje automático posteriores y para mitigar la “maldición de la dimensionalidad”.
1.1 Enfoques para la Reducción de Dimensionalidad
Existen dos enfoques principales para la reducción de dimensionalidad:
- Factorización de Matrices:
- PCA (Análisis de Componentes Principales): Descompone la matriz de datos en componentes principales
- SVD (Descomposición en Valores Singulares): Factoriza la matriz en matrices ortogonales
- NMF (Non-negative Matrix Factorization): Factorización con restricción de no negatividad
- Características:
- Basado en álgebra lineal
- Optimiza criterios globales (varianza, error de reconstrucción)
- Computacionalmente eficiente
- Menos sensible a ruido
- Grafos de Vecindad:
- t-SNE: Construye un grafo de similitud basado en probabilidades
- UMAP: Construye un grafo de vecindad difuso basado en topología
- LLE (Local Linear Embedding): Preserva relaciones de vecindad local
- Características:
- Basado en teoría de grafos y topología
- Preserva estructura local de los datos
- Mejor para visualización y descubrimiento de clusters
- Puede ser computacionalmente más costoso
2 Fundamentos Teóricos
2.1 La Función Softmax:
La función softmax es conocida por su uso de en redes neuronales para convertir números en cualquier escala a probabilidades que sumen 1.
Su trabajo es tomar un vector de números reales y transformarlo en una distribución de probabilidad, es decir, un vector de números entre 0 y 1 que suman 1.
La fórmula de Softmax para un vector \(z = [z_1, z_2, \dots, z_K]\) es:
\[\text{Softmax}(z_i) = \frac{e^{z_i}}{\sum_{j=1}^{K} e^{z_j}}\]
donde:
\(z_i\) es el \(i\)-ésimo elemento del vector de entrada.
\(K\) es el número de elementos en el vector de entrada.
Como funciona?
- Exponenciación: Primero, toma la exponencial de cada número de entrada (\(e^{z_i}\)). Esto hace que todos los números sean positivos. Además, magnifica las diferencias: un número ligeramente mayor se vuelve mucho más grande que uno ligeramente menor después de la exponenciación.
- Normalización: Luego, divide cada valor exponencial por la suma de todos los valores exponenciales. Esto asegura que todos los números resultantes estén entre 0 y 1 y que su suma sea exactamente 1.
Ejemplo Numérico:
Supongamos que tu modelo de clasificación de imágenes arroja los siguientes logits para las clases “gato”, “perro”, “pájaro”:
\(z = [z_{\text{gato}}, z_{\text{perro}}, z_{\text{pájaro}}] = [2.0, 1.0, 0.1]\)
Paso 1: Exponenciación
- \(e^{z_{\text{gato}}} = e^{2.0} \approx 7.389\)
- \(e^{z_{\text{perro}}} = e^{1.0} \approx 2.718\)
- \(e^{z_{\text{pájaro}}} = e^{0.1} \approx 1.105\)
Paso 2: Suma de los exponenciales (Denominador)
- \(\sum_{j=1}^{3} e^{z_j} = 7.389 + 2.718 + 1.105 = 11.212\)
Paso 3: Normalización (Cálculo de Softmax para cada clase)
- \(\text{Softmax}(z_{\text{gato}}) = \frac{7.389}{11.212} \approx 0.659\)
- \(\text{Softmax}(z_{\text{perro}}) = \frac{2.718}{11.212} \approx 0.242\)
- \(\text{Softmax}(z_{\text{pájaro}}) = \frac{1.105}{11.212} \approx 0.099\)
El vector de probabilidades resultante es aproximadamente \([0.659, 0.242, 0.099]\).
En el caso de t-sne la función softmax se usa para convertir las distancias euclidianas en probabilidades de pertenencia a un cluster.
2.2 La Divergencia Kullback-Leibler (KL): Midiendo la Diferencia entre Distribuciones
La Divergencia Kullback-Leibler, o simplemente KL-Divergencia, es una medida de cuánto difiere una distribución de probabilidad de otra. No es una “distancia” en el sentido matemático estricto (como la distancia euclidiana), porque no es simétrica y no satisface la desigualdad triangular.
En t-SNE, la KL-Divergencia se utiliza como la función de costo que el algoritmo intenta minimizar. Mide cuán diferentes son las probabilidades de similitud entre puntos en el espacio de alta dimensión (\(P\)) y en el espacio de baja dimensión (\(Q\)). El objetivo es hacer que \(Q\) sea lo más parecido posible a \(P\).
La fórmula de la KL-Divergencia de una distribución \(Q\) con respecto a una distribución \(P\) (es decir, \(P\) es la “verdadera” o de referencia, y \(Q\) es nuestra aproximación) es:
\[\text{KL}(P || Q) = \sum_i P(i) \log \left( \frac{P(i)}{Q(i)} \right)\]
donde:
\(P(i)\) es la probabilidad de que el evento \(i\) ocurra en la distribución \(P\).
\(Q(i)\) es la probabilidad de que el evento \(i\) ocurra en la distribución \(Q\).
La suma se realiza sobre todos los posibles eventos o valores de la distribución.
¿Cómo funciona?
La KL-Divergencia es la esperanza del logaritmo de la razón de las probabilidades entre las dos distribuciones, donde la esperanza se toma sobre la distribución \(P\).
Si \(P(i)\) y \(Q(i)\) son similares para un \(i\) dado: \(\frac{P(i)}{Q(i)}\) estará cerca de 1, y \(\log(1) = 0\). Esto contribuye poco a la divergencia.
Si \(P(i)\) es grande pero \(Q(i)\) es pequeña: \(\frac{P(i)}{Q(i)}\) será grande, y \(\log(\text{grande})\) será un número positivo grande. Esto contribuye significativamente a la divergencia, penalizando fuertemente la situación en la que \(Q\) asigna una probabilidad baja a un evento que es probable en \(P\).
Si \(P(i)\) es pequeña pero \(Q(i)\) es grande: \(\frac{P(i)}{Q(i)}\) será pequeña, y \(\log(\text{pequeña})\) será un número negativo grande. Sin embargo, como \(P(i)\) es pequeño, la contribución total \(P(i) \log \left( \frac{P(i)}{Q(i)} \right)\) será pequeña o incluso cercana a cero.
Si \(P(i) = 0\) y \(Q(i) \neq 0\): La contribución es 0 (por definición de \(\log(0/Q(i)) = \log(0)\) que es indefinido, pero el límite es \(P(i)\log P(i)\) que tiende a 0).
Si \(P(i) \neq 0\) y \(Q(i) = 0\): La divergencia se vuelve infinita. Esto significa que si la distribución de referencia \(P\) asigna alguna probabilidad a un evento, y la distribución \(Q\) le asigna cero probabilidad, la KL-Divergencia es infinita. ¡Esto es una penalización muy fuerte y deseable en t-SNE! Significa que no podemos permitir que \(Q\) no le dé probabilidad a algo que \(P\) sí considera probable.
Ejemplo Numérico: Midiendo la No-Simetría de KL
Consideremos dos distribuciones de probabilidad \(P\) y \(Q\) para un dado de 6 caras:
Distribución \(P\) (Dado Justo): \(P = [P(1), P(2), P(3), P(4), P(5), P(6)]\) \(P = [\frac{1}{6}, \frac{1}{6}, \frac{1}{6}, \frac{1}{6}, \frac{1}{6}, \frac{1}{6}] \approx [0.167, 0.167, 0.167, 0.167, 0.167, 0.167]\)
Distribución \(Q\) (Dado Cargado, favorece el 6): \(Q = [Q(1), Q(2), Q(3), Q(4), Q(5), Q(6)]\) \(Q = [0.1, 0.1, 0.1, 0.1, 0.1, 0.5]\)
Cálculo de \(\text{KL}(P || Q)\) (Cuánto difiere \(Q\) de \(P\)):
\[\text{KL}(P || Q) = \sum_{i=1}^{6} P(i) \log \left( \frac{P(i)}{Q(i)} \right)\]
- Para \(i=1, \dots, 5\): \(P(i) = \frac{1}{6}\), \(Q(i) = 0.1\)
- \(\frac{P(i)}{Q(i)} = \frac{0.167}{0.1} = \frac{0.167}{0.1} \approx 1.67\)
- \(P(i) \log \left( \frac{P(i)}{Q(i)} \right) \approx 0.167 \times \log(1.67) \approx 0.167 \times 0.513 \approx 0.0857\) (para cada uno de los 5 casos)
- Para \(i=6\): \(P(6) = \frac{1}{6}\), \(Q(6) = 0.5\)
- \(\frac{P(6)}{Q(6)} = \frac{1/6}{0.5} = \frac{0.167}{0.5} \approx 0.334\)
- \(P(6) \log \left( \frac{P(6)}{Q(6)} \right) \approx 0.167 \times \log(0.334) \approx 0.167 \times (-1.096) \approx -0.183\)
Sumando todo: \(\text{KL}(P || Q) \approx (5 \times 0.0857) + (-0.183) = 0.4285 - 0.183 = 0.2455\)
Cálculo de \(\text{KL}(Q || P)\) (Cuánto difiere \(P\) de \(Q\)):
\[\text{KL}(Q || P) = \sum_{i=1}^{6} Q(i) \log \left( \frac{Q(i)}{P(i)} \right)\]
- Para \(i=1, \dots, 5\): \(Q(i) = 0.1\), \(P(i) = \frac{1}{6}\)
- \(\frac{Q(i)}{P(i)} = \frac{0.1}{1/6} = \frac{0.1}{0.167} \approx 0.6\)
- \(Q(i) \log \left( \frac{Q(i)}{P(i)} \right) \approx 0.1 \times \log(0.6) \approx 0.1 \times (-0.511) \approx -0.0511\) (para cada uno de los 5 casos)
- Para \(i=6\): \(Q(6) = 0.5\), \(P(6) = \frac{1}{6}\)
- \(\frac{Q(6)}{P(6)} = \frac{0.5}{1/6} = \frac{0.5}{0.167} \approx 2.99\)
- \(Q(6) \log \left( \frac{Q(6)}{P(6)} \right) \approx 0.5 \times \log(2.99) \approx 0.5 \times 1.095 \approx 0.5475\)
Sumando todo: \(\text{KL}(Q || P) \approx (5 \times -0.0511) + 0.5475 = -0.2555 + 0.5475 = 0.292\)
Conclusión sobre la No-Simetría:
Como puedes ver, \(\text{KL}(P || Q) \approx 0.2455\) y \(\text{KL}(Q || P) \approx 0.292\). \(\text{KL}(P || Q) \neq \text{KL}(Q || P)\). Esto demuestra claramente que la KL-Divergencia no es simétrica. El costo de modelar mal a \(P\) usando \(Q\) no es el mismo que el costo de modelar mal a \(Q\) usando \(P\).
2.3 Breve Introducción a la Topología Algebraica (para UMAP)
La topología algebraica y la teoría de conjuntos simpliciales son fundamentales para entender UMAP. Estos conceptos nos permiten modelar la estructura de los datos de una manera que preserva tanto las relaciones locales como globales.
2.3.1 Conjuntos Simpliciales
Un simplex es la generalización de un triángulo a dimensiones arbitrarias: - 0-simplex: un punto - 1-simplex: una línea - 2-simplex: un triángulo - 3-simplex: un tetraedro - Y así sucesivamente…
Un conjunto simplicial es una colección de simplexes que se intersectan solo en sus caras comunes. En UMAP, usamos conjuntos simpliciales difusos, donde las conexiones entre puntos tienen pesos que representan la probabilidad de que exista una conexión.
2.3.2 Geometría Riemanniana
UMAP asume que los datos residen en una variedad (manifold) de baja dimensión incrustada en un espacio de alta dimensión. La geometría riemanniana nos permite: 1. Definir distancias locales en la variedad 2. Preservar la estructura topológica durante la proyección 3. Manejar la curvatura de la variedad
2.3.3 Construcción del Grafo de Vecindad
UMAP construye un grafo de vecindad en el espacio de alta dimensión siguiendo estos pasos:
Cálculo de distancias locales: Para cada punto, se calcula la distancia a su k-ésimo vecino más cercano, que define el radio de vecindad local.
Normalización de distancias: Las distancias se normalizan usando una función de kernel que convierte distancias en probabilidades de conexión.
Simetrización del grafo: Se crea un grafo no dirigido combinando las conexiones en ambas direcciones.
2.3.4 Función de Costo y Optimización
La función de costo de UMAP se basa en la entropía cruzada entre dos distribuciones de probabilidad:
\[C = \sum_{i,j} \left[ w_{ij} \log \left( \frac{w_{ij}}{q_{ij}} \right) + (1-w_{ij}) \log \left( \frac{1-w_{ij}}{1-q_{ij}} \right) \right]\]
donde: - \(w_{ij}\) es la probabilidad de conexión en el espacio de alta dimensión - \(q_{ij}\) es la probabilidad de conexión en el espacio de baja dimensión
La optimización se realiza mediante descenso de gradiente estocástico, que es más eficiente que el método usado en t-SNE.
3 t-SNE: Teoría y Algoritmo
3.1 De SNE a t-SNE: Evolución del Algoritmo
3.1.1 Stochastic Neighbor Embedding (SNE)
SNE fue el predecesor de t-SNE, desarrollado por Hinton y Roweis en 2002. El algoritmo se basa en convertir distancias euclidianas entre puntos en probabilidades de similitud. El proceso es el siguiente:
La idea de SNE es poder representar un espacio de alta dimensionalidad en un espacio de baja dimensionalidad de manera que las relaciones de vecindad se preserven. Para ello se usa la función softmax para convertir las distancias euclidianas en probabilidades de similitud. El objetivo es que las probabilidades de similitud en el espacio de baja dimensionalidad sean similares a las del espacio de alta dimensionalidad.
Probabilidades en el espacio de alta dimensión: Para cada par de puntos \(x_i\) y \(x_j\) en el espacio de alta dimensión, se calcula la probabilidad condicional \(p_{j|i}\) de que \(x_i\) elija a \(x_j\) como su vecino:
\[p_{j|i} = \frac{\exp(-\|x_i - x_j\|^2 / 2\sigma_i^2)}{\sum_{k \neq i} \exp(-\|x_i - x_k\|^2 / 2\sigma_i^2)}\]
donde \(\sigma_i\) es la varianza de la distribución gaussiana centrada en \(x_i\). Esta varianza se ajusta para cada punto \(i\) de manera que la distribución de probabilidades \(P_i\) tenga una perplejidad fija.
Probabilidades en el espacio de baja dimensión: De manera similar, para los puntos \(y_i\) y \(y_j\) en el espacio de baja dimensión:
\[q_{j|i} = \frac{\exp(-\|y_i - y_j\|^2)}{\sum_{k \neq i} \exp(-\|y_i - y_k\|^2)}\]
Aquí se usa una distribución gaussiana con varianza fija (1/2) para simplificar.
Función de costo: SNE minimiza la suma de las divergencias KL entre las distribuciones \(P_i\) y \(Q_i\):
\[C = \sum_i \text{KL}(P_i || Q_i) = \sum_i \sum_j p_{j|i} \log \frac{p_{j|i}}{q_{j|i}}\]
La función de costo es lo que el algoritmo intenta minimizar, con la idea de que las probabilidades en el espacio de baja dimensionalidad sean similares a las del espacio de alta dimensionalidad.
3.1.2 Limitaciones de SNE
SNE presentaba dos problemas principales:
- Asimetría en las probabilidades:
- Las probabilidades condicionales \(p_{j|i}\) y \(p_{i|j}\) no son iguales
- Esto puede llevar a resultados inconsistentes
- La función de costo es asimétrica respecto a \(P\) y \(Q\)
- El problema de hacinamiento (crowding problem):
- En el espacio de baja dimensión, hay menos “espacio” disponible para que los puntos se separen y las probabilidades de vecindad sean similares a las del espacio de alta dimensionalidad.
- Los puntos tienden a aglomerarse en el centro
- La distribución gaussiana en baja dimensión no maneja bien este problema
- Las colas de la gaussiana decaen muy rápido (\(e^{-x^2}\))
3.1.3 La Solución: t-SNE
t-SNE resuelve estos problemas mediante :
- Probabilidades conjuntas simétricas:
- Reemplaza las probabilidades condicionales por probabilidades conjuntas
- \(p_{ij} = \frac{p_{j|i} + p_{i|j}}{2N}\)
- Esto asegura que \(p_{ij} = p_{ji}\)
- La función de costo se vuelve simétrica
- Distribución t de Student en baja dimensión:
- Reemplaza la distribución gaussiana por una t de Student con un grado de libertad
- La fórmula para \(q_{ij}\) se convierte en: \[q_{ij} = \frac{(1 + \|y_i - y_j\|^2)^{-1}}{\sum_{k \neq l} (1 + \|y_k - y_l\|^2)^{-1}}\]
La distribución t de Student tiene “colas pesadas” (heavy tails), lo que significa que: - Asigna una probabilidad significativa a valores lejos de la media - Permite que puntos moderadamente separados en alta dimensión se mapeen a distancias mayores en baja dimensión - Crea más “espacio” en el centro del mapa - Evita la aglomeración excesiva de puntos
La fórmula de la distribución t de Student con un grado de libertad es: \[f(x) = \frac{1}{\pi(1 + x^2)}\]
Esta función tiene colas que decaen como \(1/x^2\), lo que es más lento que la distribución gaussiana que decae como \(e^{-x^2}\). Esta propiedad es clave para resolver el problema de hacinamiento.
3.1.4 Función de Costo de t-SNE
La función de costo de t-SNE es una divergencia KL entre las probabilidades conjuntas \(P\) y \(Q\):
\[C = \text{KL}(P || Q) = \sum_i \sum_j p_{ij} \log \frac{p_{ij}}{q_{ij}}\]
3.1.5 Gradiente de la Función de Costo
El gradiente de la función de costo con respecto a \(y_i\) es:
\[\frac{\partial C}{\partial y_i} = 4 \sum_j (p_{ij} - q_{ij})(y_i - y_j)(1 + \|y_i - y_j\|^2)^{-1}\]
Este gradiente tiene una interpretación física intuitiva: - Si \(p_{ij} > q_{ij}\): Los puntos \(i\) y \(j\) están más cerca en alta dimensión que en baja dimensión * Se crea una fuerza atractiva que los acerca - Si \(p_{ij} < q_{ij}\): Los puntos \(i\) y \(j\) están más lejos en alta dimensión que en baja dimensión * Se crea una fuerza repulsiva que los aleja * La fuerza se modera por el término \((1 + \|y_i - y_j\|^2)^{-1}\)
El término \((1 + \|y_i - y_j\|^2)^{-1}\) es crucial porque: - Modera la fuerza de repulsión entre puntos ya separados - Permite que los puntos se separen más fácilmente - Contribuye a la formación de clusters bien definidos
3.2 Algoritmo de Optimización
El algoritmo de t-SNE utiliza un algoritmo de descenso de gradiente para minimizar la función de costo. Se aplican técnicas como:
- Momentum: Para acelerar la convergencia y evitar mínimos locales. La actualización de las coordenadas \(y_i\) en cada iteración \(t\) es: \[ Y^{(t)} = Y^{(t-1)} + \eta \frac{\partial C}{\partial Y} + \alpha(t) (Y^{(t-1)} - Y^{(t-2)}) \] donde \(\eta\) es la tasa de aprendizaje y \(\alpha(t)\) es el término de momentum.
- Ajuste del learning rate: Se suele usar un learning rate que se incrementa en las primeras iteraciones y luego se mantiene constante.
- Inicialización: Los puntos \(y_i\) se inicializan aleatoriamente de una distribución normal con una pequeña varianza.
3.3 Algoritmo de t-SNE
El algoritmo de t-SNE se puede describir de la siguiente manera:
Algoritmo 1: Versión Simple de t-Distributed Stochastic Neighbor Embedding.
Datos: conjunto de datos \(X = \{x_1, x_2,..., x_n\}\), parámetros de la función de costo: perplejidad \(Perp\), parámetros de optimización: número de iteraciones \(T\), tasa de aprendizaje \(\eta\), momento \(\alpha(t)\).
Resultado: representación de baja dimensión \(Y^{(T)} = \{y_1, y_2,..., y_n\}\).
Inicio:
calcular afinidades por pares \(p_{j|i}\) con perplejidad \(Perp\) (usando Ecuación 1)
establecer \(p_{ij} = \frac{p_{j|i} + p_{i|j}}{2n}\)
muestrear solución inicial \(Y^{(0)} = \{y_1, y_2,..., y_n\}\) desde \(\mathcal{N}(0,10^{-4}I)\)
para \(t=1\) hasta \(T\) hacer
- calcular afinidades de baja dimensión \(q_{ij}\) (usando Ecuación 4)
- calcular gradiente \(\frac{\partial C}{\partial Y}\) (usando Ecuación 5)
- establecer \(Y^{(t)} = Y^{(t-1)} + \eta\frac{\partial C}{\partial Y} + \alpha(t)(Y^{(t-1)} - Y^{(t-2)})\)
Fin
La actualización de los puntos en cada iteración \(t\) se realiza mediante la ecuación:
\(Y^{(t)} = Y^{(t-1)} + \eta\frac{\partial C}{\partial Y} + \alpha(t)(Y^{(t-1)} - Y^{(t-2)})\)
Donde:
- \(Y^{(t)}\): Es la nueva posición de los puntos en la iteración \(t\)
- \(Y^{(t-1)}\): Es la posición actual de los puntos
- \(\eta\): Es la tasa de aprendizaje (learning rate)
- \(\frac{\partial C}{\partial Y}\): Es el gradiente de la función de costo
- \(\alpha(t)\): Es el término de momento
- \((Y^{(t-1)} - Y^{(t-2)})\): Es el cambio en la posición del paso anterior
El movimiento de los puntos está determinado por dos componentes principales:
- Término del gradiente (\(\eta\frac{\partial C}{\partial Y}\)):
- Mueve los puntos en la dirección que minimiza la divergencia KL
- Los puntos se mueven para preservar la estructura de vecindad
- Si dos puntos están cerca en el espacio original, tenderán a moverse uno hacia el otro
- Si dos puntos están lejos en el espacio original, tenderán a alejarse
- Término de momento (\(\alpha(t)(Y^{(t-1)} - Y^{(t-2)})\)):
- Ayuda a evitar mínimos locales
- Mantiene cierta “inercia” del movimiento anterior
- Ayuda a que la optimización sea más estable
- El factor \(\alpha(t)\) controla cuánto del movimiento anterior se mantiene
3.3.1 Variante con Inicialización PCA
Una variante común del algoritmo t-SNE utiliza PCA (Análisis de Componentes Principales) para inicializar los puntos en lugar de usar una distribución normal aleatoria. Esta variante tiene las siguientes características:
- Inicialización con PCA:
- En lugar de \(Y^{(0)} \sim \mathcal{N}(0,10^{-4}I)\), se usa \(Y^{(0)} = \text{PCA}(X)\)
- Esto proporciona una mejor posición inicial que preserva la estructura global de los datos
- Puede acelerar la convergencia del algoritmo
- Ayuda a evitar mínimos locales pobres
3.3.2 Ejemplo del algoritmo
A continuación, implementaremos t-SNE paso a paso para proyectar datos de \(\mathbb{R}^2\) a \(\mathbb{R}^1\). Generaremos tres distribuciones normales con diferentes medias y varianzas, y seguiremos el proceso de optimización en diferentes iteraciones.
| Iteración | Separación Promedio | Varianza Intra-cluster | Ratio de Separación | |
|---|---|---|---|---|
| 0 | 1 | 0.000000 | 0.000000 | 5.941000 |
| 1 | 10 | 0.127000 | 31.536000 | 0.004000 |
| 2 | 25 | 0.398000 | 30.295000 | 0.013000 |
| 3 | 50 | 5.359000 | 26.847000 | 0.200000 |
| 4 | 100 | 23.194000 | 29.728000 | 0.780000 |
| 5 | 250 | 33.021000 | 29.614000 | 1.115000 |
| 6 | 500 | 34.610000 | 56.808000 | 0.609000 |
| 7 | 1000 | 31.961000 | 49.981000 | 0.639000 |
Este ejemplo muestra:
- Generación de datos:
- Tres clusters gaussianos en \(\mathbb{R}^2\)
- Cada cluster tiene 100 puntos
- Diferentes medias y varianzas para cada cluster
- Implementación paso a paso:
- Cálculo de probabilidades en alta dimensión (\(p_{ij}\))
- Cálculo de probabilidades en baja dimensión (\(q_{ij}\))
- Cálculo del gradiente
- Actualización de posiciones con momentum
- Visualización del proceso:
- Datos originales en \(\mathbb{R}^2\)
- Proyección en \(\mathbb{R}^1\) en diferentes iteraciones
- Comparación con la implementación de scikit-learn
- Observaciones:
- Los clusters se separan gradualmente
- El momentum ayuda a evitar mínimos locales
- La estructura de vecindad se preserva en la proyección
3.4 Extensiones y Variaciones
El artículo también discute extensiones como:
- t-SNE para conjuntos de datos grandes: Se propone una técnica de random walks en grafos de vecindad para manejar grandes volúmenes de datos, donde solo un subconjunto de puntos se visualiza directamente, pero la estructura global influye en el embedding.
- t-SNE con costos de incrustación tempranos (early exaggeration): Multiplicar los \(p_{ij}\) por un factor (ej. 4 o 12) en las primeras iteraciones para crear clústeres más compactos y evitar que se formen “mini-clústeres” que no se pueden separar más tarde. \[ p'_{ij} = p_{ij} \times \text{exaggeration\_factor} \] para las primeras \(T\) iteraciones.
4 UMAP: Teoría y Algoritmo
UMAP (Uniform Manifold Approximation and Projection) es una técnica de reducción de dimensionalidad no lineal desarrollada por Leland McInnes, John Healy y James Melville. Su propósito central es proyectar datos de alta dimensión en un espacio de menor dimensión (comúnmente 2D o 3D) para visualización o como un paso de preprocesamiento en pipelines de aprendizaje automático.
A diferencia de técnicas como t-SNE, que se basan en probabilidades de similitud y optimización de la divergencia KL, UMAP se asienta sobre un marco teórico robusto derivado de la geometría riemanniana y la topología algebraica. Esta base le confiere propiedades distintivas en términos de velocidad, escalabilidad y una superior preservación de la estructura global de los datos.
4.1 Fundamentos Teóricos de UMAP: Una Perspectiva Topológica
La potencia de UMAP radica en su suposición fundamental de que los datos de alta dimensión se encuentran aproximadamente sobre una variedad (manifold) riemanniana de baja dimensión. El objetivo principal del algoritmo es preservar la estructura topológica de esta variedad subyacente al proyectar los datos a un espacio de menor dimensionalidad. La teoría subyacente se expresa más fácilmente en el lenguaje de la topología y la teoría de categorías.
A un alto nivel, UMAP logra esto utilizando aproximaciones locales de la variedad. Estas aproximaciones se “parchean” o unen a través de representaciones de conjuntos simpliciales difusos (fuzzy simplicial sets) para construir una representación topológica coherente de los datos en alta dimensión. Posteriormente, se construye una representación topológica similar en el espacio de baja dimensión. El algoritmo optimiza entonces la disposición de los puntos en el espacio de baja dimensión para minimizar la entropía cruzada entre ambas representaciones topológicas.
La construcción de estas representaciones topológicas difusas se desglosa en dos problemas: 1. Aproximar la variedad sobre la que se asume que se encuentran los datos. 2. Construir una representación de conjunto simplicial difuso de la variedad aproximada.
En última instancia, UMAP se puede entender, desde una perspectiva computacional, como la construcción y operación sobre grafos ponderados, situándolo en la clase de algoritmos de aprendizaje basados en \(k\)-vecinos (como Laplacian Eigenmaps, Isomap y t-SNE). Las diferencias entre estos algoritmos residen en los detalles de cómo se construye el grafo y cómo se calcula su disposición en baja dimensión.
4.1.1 Distribución Uniforme de Datos en una Variedad y Aproximación Geodésica
El primer paso crucial en UMAP es aproximar la variedad subyacente. Se asume que los datos están distribuidos uniformemente en esta variedad con respecto a una métrica riemanniana \(g\) intrínseca a la misma, no necesariamente la métrica euclidiana del espacio ambiente. Aunque los datos reales rara vez se comportan así, UMAP aborda esto de manera ingeniosa: adapta la métrica localmente para que los datos parezcan uniformemente distribuidos.
Formalmente, para cada punto \(x_i\), UMAP normaliza las distancias a sus vecinos con respecto a la distancia a su \(k\)-ésimo vecino más cercano, denotada \(\rho_i\). Esto se basa en el Lema 1 (discutido en el paper), que establece que, bajo ciertas condiciones de un manifold Riemanniano \((M,g)\), en una bola \(B\) con respecto a \(g\) centrada en un punto \(p \in M\), la distancia geodésica de \(p\) a cualquier \(q \in B\) es proporcional a la distancia euclidiana en el espacio ambiente \(d_{\mathbb{R}^n}(p,q)\), escalada por el radio de la bola \(r\):
\[\frac{1}{r} d_{\mathbb{R}^n}(p,q)\]
La implicación práctica es que, al crear una distancia personalizada para cada \(x_i\) (normalizando por \(\rho_i\)), se asegura que la suposición de distribución uniforme en la variedad sea válida localmente. El “costo” es que se generan nociones de distancia locales e independientes para cada punto, que pueden no ser directamente compatibles entre sí. La tarea siguiente es fusionar estos “espacios métricos discretos” locales en una estructura global consistente.
4.1.2 Representación de la Variedad con Conjuntos Simpliciales Difusos
La forma en que UMAP unifica estas nociones locales es a través de los conjuntos simpliciales difusos.
- Un simplex es una generalización de elementos geométricos básicos: un punto es un 0-simplex, una arista es un 1-simplex, un triángulo es un 2-simplex, etc. Un conjunto simplicial es una colección de estos simplices que se conectan entre sí para formar una representación discreta de una forma o espacio topológico.
- El término “difuso” (fuzzy) significa que las conexiones entre los simplices no son binarias (existe/no existe), sino que tienen un grado de membresía o probabilidad (un valor en el intervalo \([0, 1]\)). Esto permite capturar la incertidumbre y la gradualidad en las relaciones de vecindad de los datos, lo que es crucial para manejar la complejidad de la alta dimensionalidad y permite la combinación de las métricas locales inconsistentes en una estructura global.
Computacionalmente, aunque la teoría habla de conjuntos simpliciales difusos completos, en la práctica UMAP trabaja con el “one skeleton” de estos conjuntos, lo que se traduce directamente en un grafo ponderado. En este grafo: * Cada punto de datos \(x_i\) es un nodo. * Cada arista entre \(x_i\) y \(x_j\) tiene un peso que representa la “fuerza” o “probabilidad” de conexión entre ellos.
4.2 Una Vista Computacional del Algoritmo UMAP
Desde una perspectiva práctica, el algoritmo UMAP se descompone en dos fases principales, características de los algoritmos de reducción de dimensionalidad basados en grafos:
4.2.1 Fase 1: Construcción del Grafo Ponderado de Alta Dimensión
Esta fase se centra en transformar los datos de alta dimensión en un grafo disperso que capture su estructura topológica local.
Cálculo de Distancias y Normalización Adaptativa:
- Para cada punto \(x_i \in X\), se calculan las distancias euclidianas \(d(x_i, x_j)\) a sus \(k\)-vecinos más cercanos (parámetro
n_neighbors). - Se determina la distancia \(\rho_i\) al \(k\)-ésimo vecino más cercano de \(x_i\).
- Se calcula un valor \(\sigma_i\) para cada \(x_i\) mediante una búsqueda binaria que asegura que la suma de las probabilidades de conexión a sus \(k\) vecinos sea \(\log_2(k)\). Es decir, se encuentra \(\sigma_i\) tal que:
\[ \sum_{j=1}^{k} \exp\left( - \frac{\text{dist}(x_i, x_j) - \rho_i}{\sigma_i} \right) = \log_2(k) \]
- Para cada punto \(x_i \in X\), se calculan las distancias euclidianas \(d(x_i, x_j)\) a sus \(k\)-vecinos más cercanos (parámetro
Cálculo de Conectividades Difusas (Probabilidades de Existencia de Aristas):
- La conectividad dirigida (probabilidad de conexión) de \(x_i\) a \(x_j\) para sus \(k\)-vecinos se define como:
\[\mu_{ij} = \exp\left( - \max(0, \frac{\text{dist}(x_i, x_j) - \rho_i}{\sigma_i}) \right)\]
- El \(\max(0, \cdot)\) asegura que los valores \(\mu_{ij}\) no excedan 1 (ya que \(\text{dist}(x_i, x_j)\) puede ser menor que \(\rho_i\)).
Simetrización del Grafo:
- El grafo de conectividades \(\mu_{ij}\) es asimétrico. Para obtener un grafo no dirigido que represente la conectividad mutua, UMAP simetriza las aristas utilizando una operación de unión probabilística:
\[w_{ij} = \mu_{ij} + \mu_{ji} - (\mu_{ij} \cdot \mu_{ji})\]
- Este \(w_{ij} \in [0, 1]\) es el peso final de la arista entre \(x_i\) y \(x_j\), representando la fuerza mutua de la conexión. Las aristas con \(w_{ij} > 0\) forman el grafo ponderado disperso G en el espacio de alta dimensión, que es la representación topológica de los datos fuente.
4.2.2 Fase 2: Cálculo del Diseño (Layout) en Baja Dimensión
Esta fase implica encontrar una representación de baja dimensión de los puntos que preserve la estructura del grafo G.
Definición de la Conectividad en Baja Dimensión:
- Para el espacio de baja dimensión (embedding) \(Y = \{y_1, \ldots, y_N\}\), se define una función de conectividad \(q_{ij}\) que representa la similitud entre \(y_i\) e \(y_j\). Esta función es flexible y se parametriza por los parámetros de usuario
min_distyspread. Los valores de \(a\) y \(b\) se derivan de estos parámetros para controlar la forma de la curva. Una forma común es:
\[q_{ij} = (1 + a\|y_i - y_j\|^{2b})^{-1}\]
- Esta función permite que las distancias pequeñas en el embedding se mapeen a una mayor variabilidad (lo que ayuda a la separación de clusters) y que las distancias grandes se compriman (preservando la estructura global).
- Para el espacio de baja dimensión (embedding) \(Y = \{y_1, \ldots, y_N\}\), se define una función de conectividad \(q_{ij}\) que representa la similitud entre \(y_i\) e \(y_j\). Esta función es flexible y se parametriza por los parámetros de usuario
Inicialización de la Incrustación:
- La incrustación de baja dimensión \(\{y_i\}\) puede inicializarse aleatoriamente. Sin embargo, para una convergencia más rápida y mayor estabilidad, UMAP prefiere usar un diseño espectral. Esto se basa en la propiedad de que el laplaciano simétrico del grafo G es una aproximación discreta del operador de Laplace-Beltrami de la variedad, y sus eigenvectores pueden proporcionar una buena aproximación inicial de la estructura global.
Optimización del Diseño Mediante Descenso de Gradiente Estocástico:
- El objetivo es minimizar la entropía cruzada entre el grafo de alta dimensión \(G\) (con pesos \(w_{ij}\)) y el grafo de baja dimensión \(H\) (con pesos \(q_{ij}\)). La función de costo es:
\[C = \sum_{i,j \text{ s.t. } i \neq j} \left[ w_{ij} \log \left( \frac{w_{ij}}{q_{ij}} \right) + (1-w_{ij}) \log \left( \frac{1-w_{ij}}{1-q_{ij}} \right) \right]\]
- La optimización se realiza mediante un proceso iterativo de descenso de gradiente estocástico. El gradiente de \(C\) induce fuerzas de atracción y repulsión:
- Atracción: Los términos \(w_{ij} \log \left( \frac{w_{ij}}{q_{ij}} \right)\) representan la atracción. Si dos puntos son fuertemente conectados en alta dimensión (\(w_{ij}\) es alto), pero están lejos en baja dimensión (\(q_{ij}\) es bajo), este término impulsa a \(y_i\) e \(y_j\) a acercarse.
- Repulsión: Los términos \((1-w_{ij}) \log \left( \frac{1-w_{ij}}{1-q_{ij}} \right)\) representan la repulsión. Si dos puntos no están conectados en alta dimensión (\(w_{ij}\) es bajo), pero están demasiado cerca en baja dimensión (\(q_{ij}\) es alto), este término impulsa a \(y_i\) e \(y_j\) a alejarse.
- UMAP mejora la eficiencia de la repulsión muestreando solo un subconjunto de “no-vecinos” en cada iteración, en lugar de considerar todas las pares de puntos no conectadas. Esto reduce drásticamente la complejidad computacional.
El resultado final de la optimización es un conjunto de coordenadas \(\{y_i\}\) en el espacio de baja dimensión que minimiza la discrepancia topológica entre la representación original y la incrustación, proporcionando una visualización que fielmente representa la estructura de los datos.
4.3 Implementación y Análisis de UMAP
Aplicaremos UMAP al mismo dataset, explorando el efecto de sus hiperparámetros clave en la visualización y comparándolo con t-SNE.
| Iteración | Separación Promedio | Varianza Intra-cluster | Ratio de Separación | |
|---|---|---|---|---|
| 0 | 1 | 0.410000 | 0.004000 | 112.859000 |
| 1 | 10 | 0.486000 | 0.005000 | 101.093000 |
| 2 | 25 | 0.692000 | 0.009000 | 80.844000 |
| 3 | 50 | 1.137000 | 0.019000 | 59.871000 |
| 4 | 100 | 2.198000 | 0.063000 | 34.660000 |
| 5 | 250 | 5.215000 | 0.808000 | 6.451000 |
| 6 | 500 | 9.276000 | 3.412000 | 2.718000 |
| 7 | 1000 | 12.610000 | 6.458000 | 1.953000 |
Este ejemplo muestra:
- Generación de datos:
- Tres clusters gaussianos en \(\mathbb{R}^2\)
- Cada cluster tiene 100 puntos
- Diferentes medias y varianzas para cada cluster
- Implementación paso a paso:
- Cálculo de probabilidades en alta dimensión (\(p_{ij}\))
- Cálculo de probabilidades en baja dimensión (\(q_{ij}\))
- Cálculo del gradiente
- Actualización de posiciones con momentum
- Visualización del proceso:
- Datos originales en \(\mathbb{R}^2\)
- Proyección en \(\mathbb{R}^1\) en diferentes iteraciones
- Comparación con la implementación de scikit-learn
- Observaciones:
- Los clusters se separan gradualmente
- El momentum ayuda a evitar mínimos locales
- La estructura de vecindad se preserva en la proyección
4.4 Ventajas Clave de UMAP
UMAP se compara favorablemente con t-SNE y otros algoritmos de la misma clase (basados en grafos de \(k\)-vecinos). Su principal ventaja es que sus elecciones algorítmicas, tanto en la construcción del grafo como en el diseño de la incrustación, tienen una justificación teórica clara derivada de sus axiomas sobre la variedad y la topología, lo que le permite ser:
- Más Rápido y Escalable: Su optimización en grafos dispersos y el muestreo eficiente de no-vecinos lo hacen significativamente más rápido que t-SNE, siendo aplicable a datasets de millones de puntos con una complejidad computacional que se aproxima a \(O(N \log N)\).
- Mejor Preservación de la Estructura Global: La naturaleza de su función objetivo y la forma en que maneja las distancias adaptativas le permiten mantener de manera más consistente las relaciones a gran escala entre los clusters, además de la estructura local.
- Flexible y Controlable: Los parámetros
min_distyspreadofrecen un control intuitivo sobre la densidades y separación de los clusters en la visualización final. - Capacidad de Transformación: UMAP puede aprender una transformación desde el espacio de alta a baja dimensión, lo que permite proyectar nuevos datos en un embedding existente sin recalcularlo todo.
5 Comparativa t-SNE vs UMAP
Ambas t-SNE y UMAP son herramientas poderosas para la reducción de dimensionalidad no lineal y la visualización, buscando revelar la estructura intrínseca de los datos. Sin embargo, sus fundamentos matemáticos y sus enfoques computacionales les otorgan características y rendimientos distintivos.
| Característica | t-SNE | UMAP |
|---|---|---|
| Fundamentos Teóricos | Teoría de probabilidades, divergencia Kullback-Leibler. Busca preservar las probabilidades de similitud (vecindad). | Topología algebraica, teoría de la geometría riemanniana, conjuntos simpliciales difusos. Busca preservar la estructura topológica (conectividad). |
| Concepto de Similitud | Probabilidades de similitud \(p_{ij}\) (basadas en Gaussianas) en alta dimensión y \(q_{ij}\) (basadas en t-Student) en baja dimensión. | Conectividad en un grafo ponderado (fuzzy simplicial set) que representa la proximidad. La noción de “vecino” es localmente adaptable. |
| Preservación de Estructura | Excelente para la estructura local (clusters). Tiende a aglomerar puntos cercanos y separarlos bien. A menudo distorsiona la estructura global (las distancias entre clusters no son fiables). | Excelente para estructura local Y global. Busca preservar tanto los clusters como las relaciones entre ellos. Es más probable que las distancias entre clusters tengan significado. |
| Función de Costo | Divergencia Kullback-Leibler (KL) asimétrica: \(\text{KL}(P || Q)\). Penaliza fuertemente la pérdida de vecinos cercanos. | Inspirada en la entropía cruzada binaria, optimizada para la correspondencia de grafos: \(\sum [w \log(w/q) + (1-w) \log((1-w)/(1-q))]\). |
| Distribución en Baja Dimensión | Distribución t-Student con 1 grado de libertad (Cauchy). Sus colas pesadas resuelven el “problema de hacinamiento”. | Función de conectividad personalizada $ (1 + a|y_i - y_j|{2b}){-1} $. Parametros min_dist y spread controlan su forma para influir en la dispersión. |
| Velocidad y Escalabilidad | Generalmente lento. Su complejidad es \(O(N^2)\) (o \(O(N \log N)\) con optimizaciones como la del árbol de Barnes-Hut). No es ideal para datasets con más de ~50,000 puntos. | Significativamente más rápido. Su complejidad es \(O(N \log N)\) para la construcción del grafo y luego \(O(N)\) para la optimización. Puede manejar datasets de millones de puntos. |
| Reproductibilidad | Muy sensible a los parámetros (perplexity, learning_rate, init). Ejecuciones repetidas con diferentes random_state pueden producir visualizaciones notablemente diferentes. |
Generalmente más robusto a los cambios de parámetros y más consistente en la estructura global resultante entre ejecuciones. |
| Parámetros Clave | perplexity (número de “vecinos efectivos”), learning_rate (tasa de aprendizaje). |
n_neighbors (número de vecinos para construir el grafo inicial), min_dist (separación mínima entre puntos proyectados), spread (escala de los clusters), metric (métrica de distancia). |
| Forma de los Clusters | Tiende a producir clusters más densos y circulares, a veces con puntos aglomerados en el centro del mapa. | Puede producir clusters con formas más diversas y una mejor separación visual, reflejando mejor la estructura intrínseca de los datos. |
| Aplicaciones Típicas | Excelente para la visualización de datos de transcriptómica (ej. single-cell RNA-seq), imágenes, texto. Muy bueno para identificar subpoblaciones distintas. | Ampliamente utilizado en biología (ej. single-cell), visualización de embeddings de procesamiento del lenguaje natural (NLP), análisis de imágenes grandes. A menudo es la opción preferida por su equilibrio entre velocidad y calidad del embedding. |
5.0.1 Enfoques Distintivos en la Práctica:
t-SNE como “Microscopio Local”: t-SNE se comporta como un “microscopio” que se enfoca en las relaciones locales y los detalles finos de los clusters. Es excelente para identificar subgrupos dentro de sus datos. Sin embargo, no siempre garantiza que los grupos que están muy separados en el gráfico también lo estén en el espacio de alta dimensión, ni que el tamaño de los grupos sea proporcional a su número de puntos.
UMAP como “Mapa Global”: UMAP, al basarse en una aproximación de la topología del manifold, busca preservar las conexiones tanto locales como globales. Esto significa que las distancias relativas entre los clusters en el mapa de UMAP suelen ser más significativas que en t-SNE. UMAP es más adecuado cuando se desea comprender la estructura general del conjunto de datos, las relaciones entre los grandes grupos y la forma general de la “nube” de datos.
En resumen, la elección entre t-SNE y UMAP a menudo depende del objetivo específico de la visualización y las características del dataset. Para conjuntos de datos grandes y para una comprensión tanto local como global, UMAP es generalmente preferible. Para un enfoque profundo en la separación de clusters locales en datasets de tamaño moderado, t-SNE sigue siendo una excelente herramienta.
6 Autoencoders (en veremos)
6.1 Fundamentos Teóricos
Los Autoencoders son una clase de redes neuronales artificiales utilizadas para el aprendizaje no supervisado de representaciones. La arquitectura básica consta de dos partes principales:
- Codificador (Encoder): Una red neuronal que transforma los datos de entrada de alta dimensión en una representación de menor dimensión (código o embedding).
- Decodificador (Decoder): Una red neuronal que reconstruye los datos originales a partir del código de baja dimensión.
La idea es que el autoencoder aprenda a reconstruir los datos de entrada a partir de la representación latente. La representación latente es una representación de los datos de entrada que es más fácil de procesar y que captura la información más importante de los datos.Esto es lo que se proyecta en el espacio de baja dimensión.
6.2 Proceso de Aprendizaje
El entrenamiento de un autoencoder sigue estos pasos:
Codificación: Los datos de entrada \(x\) pasan a través del encoder, produciendo una representación latente \(z\): \[z = f_\theta(x)\] donde \(f_\theta\) es la función del encoder con parámetros \(\theta\).
Decodificación: La representación latente \(z\) pasa a través del decoder, produciendo una reconstrucción \(\hat{x}\): \[\hat{x} = g_\phi(z)\] donde \(g_\phi\) es la función del decoder con parámetros \(\phi\).
Optimización: Los parámetros \(\theta\) y \(\phi\) se optimizan para minimizar el error de reconstrucción: \[\mathcal{L}(x, \hat{x}) = \|x - \hat{x}\|^2\]
7 Implementación en el dataset MNIST
En esta sección, aplicaremos tanto t-SNE como UMAP al dataset de dígitos de Scikit-learn y analizaremos los resultados, comparando las visualizaciones y las métricas de calidad de las proyecciones.
7.1 Preparación del Entorno y Carga de Datos
Dimensiones de los datos de las imágenes (X): (1797, 64) Dimensiones de las etiquetas de las clases (y): (1797,)
7.2 Representación de Imágenes como Matrices
Para procesar imágenes con algoritmos de machine learning, es fundamental entender cómo se representan numéricamente. Las imágenes, en esencia, son rejillas de píxeles, donde cada píxel tiene un valor numérico que representa su intensidad o color.
7.2.1 Imágenes en Escala de Grises
Una imagen en escala de grises se representa como una matriz 2D, donde cada elemento de la matriz corresponde a un píxel y su valor representa la intensidad del gris (típicamente entre 0 para negro y 255 para blanco, u otros rangos dependiendo del formato).
En nuestro ejemplo, el dataset de dígitos de Scikit-learn consta de imágenes de 8x8 píxeles en escala de grises. Cada imagen individual se puede visualizar como una matriz de 8x8:
\[\begin{pmatrix} valor_{0,0} & valor_{0,1} & \dots & valor_{0,7} \\ valor_{1,0} & valor_{1,1} & \dots & valor_{1,7} \\ \vdots & \vdots & \ddots & \vdots \\ valor_{7,0} & valor_{7,1} & \dots & valor_{7,7} \end{pmatrix}\]
7.2.2 Imágenes a Color (RGB)
Las imágenes a color, comúnmente en formato RGB (Rojo, Verde, Azul), se representan como tensores 3D. Tienen dimensiones de altura, ancho y canales de color. Para una imagen RGB, hay 3 canales:
\[\text{Imagen RGB} \in \mathbb{R}^{\text{altura} \times \text{ancho} \times 3}\]
Cada canal es una matriz 2D que representa la intensidad de ese color específico para cada píxel. La combinación de los valores en los tres canales para un píxel dado determina su color final.
7.2.3 Aplanamiento (Flattening) para Algoritmos Lineales
Algoritmos como t-SNE o PCA trabajan con vectores de características de una sola dimensión. Por lo tanto, es necesario “aplanar” la representación matricial o tensorial de cada imagen en un único vector largo.
Para una imagen de 8x8 como en el dataset de dígitos, la matriz 2D de 8x8 (64 píxeles) se aplana en un vector 1D de 64 elementos:
\[\begin{pmatrix} valor_{0,0} \\ valor_{0,1} \\ \vdots \\ valor_{7,7} \end{pmatrix}_{64 \times 1}\]
Para una imagen RGB de altura x ancho x 3 canales, el tensor 3D se aplana en un vector 1D de altura \(\times\) ancho \(\times\) 3 elementos. Por ejemplo, una imagen de 100x100 píxeles RGB se convertiría en un vector de \(100 \times 100 \times 3 = 30,000\) elementos.
Este vector aplanado se convierte en la “muestra” o “instancia” de datos en el conjunto de datos de entrada para t-SNE, donde cada elemento del vector es una “característica” (un valor de píxel).
7.3 Visualización Tabular de los Datos (DataFrame)
Para comprender mejor la estructura de los datos aplanados antes de aplicar los algoritmos de reducción de dimensionalidad, podemos visualizarlos en un formato tabular, como un DataFrame de Pandas. Cada fila representará una imagen aplanada (una muestra), y cada columna representará un píxel específico (una característica).
| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | ... | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | digito | |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 0 | 0.0 | 0.0 | 5.0 | 13.0 | 9.0 | 1.0 | 0.0 | 0.0 | 0.0 | 0.0 | ... | 0.0 | 0.0 | 0.0 | 6.0 | 13.0 | 10.0 | 0.0 | 0.0 | 0.0 | 0 |
| 1 | 0.0 | 0.0 | 0.0 | 12.0 | 13.0 | 5.0 | 0.0 | 0.0 | 0.0 | 0.0 | ... | 0.0 | 0.0 | 0.0 | 0.0 | 11.0 | 16.0 | 10.0 | 0.0 | 0.0 | 1 |
| 2 | 0.0 | 0.0 | 0.0 | 4.0 | 15.0 | 12.0 | 0.0 | 0.0 | 0.0 | 0.0 | ... | 0.0 | 0.0 | 0.0 | 0.0 | 3.0 | 11.0 | 16.0 | 9.0 | 0.0 | 2 |
| 3 | 0.0 | 0.0 | 7.0 | 15.0 | 13.0 | 1.0 | 0.0 | 0.0 | 0.0 | 8.0 | ... | 0.0 | 0.0 | 0.0 | 7.0 | 13.0 | 13.0 | 9.0 | 0.0 | 0.0 | 3 |
| 4 | 0.0 | 0.0 | 0.0 | 1.0 | 11.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | ... | 0.0 | 0.0 | 0.0 | 0.0 | 2.0 | 16.0 | 4.0 | 0.0 | 0.0 | 4 |
5 rows × 65 columns
En este DataFrame, cada una de las primeras 64 columnas (pixel_0 a pixel_63) representan la intensidad aplanada de un píxel de la imagen de 8x8. La última columna (digito) contiene la etiqueta de la clase (el dígito que representa la imagen).
Esta vista nos permite ver los valores numéricos exactos que alimentan los algoritmos.
7.4 Visualización de Datos Originales
7.5 Implementación y Análisis de t-SNE
En esta subsección, aplicaremos t-SNE al dataset de dígitos y exploraremos el proceso de optimización y el efecto de sus hiperparámetros.
7.5.1 Proceso de Optimización de t-SNE
7.5.2 Análisis de la Convergencia de t-SNE
7.5.3 Efecto de los Hiperparámetros de t-SNE
7.6 Implementación y Análisis de UMAP en MNIST
En esta sección, aplicaremos UMAP al dataset de dígitos MNIST usando scikit-learn y analizaremos su comportamiento y parámetros.
8 Referencias
A completar